#pragma once
#include <memory>
#include <functional>
#include "fields.hpp"

namespace bitrpc
{

    // 基础消息类，定义消息的通用接口
    class BaseMessage
    {
    public:
        using ptr = std::shared_ptr<BaseMessage>; // 智能指针类型

        virtual ~BaseMessage() {}                                // 虚析构函数
        virtual void setId(const std::string &id) { _rid = id; } // 设置消息ID
        virtual std::string rid() { return _rid; }               // 获取消息ID
        virtual void setMType(MType mtype) { _mtype = mtype; }   // 设置消息类型
        virtual MType mtype() { return _mtype; }                 // 获取消息类型
        virtual std::string serialize() = 0;                     // 序列化消息
        virtual bool unserialize(const std::string &msg) = 0;    // 反序列化消息
        virtual bool check() = 0;                                // 检查消息合法性

    private:
        MType _mtype;     // 消息类型
        std::string _rid; // 消息ID
    };

    // 基础缓冲区类，定义数据读取和写入的通用接口
    class BaseBuffer
    {
    public:
        using ptr = std::shared_ptr<BaseBuffer>; // 智能指针类型

        virtual size_t readableSize() = 0;                    // 获取可读数据大小
        virtual int32_t peekInt32() = 0;                      // 查看下一个32位整数
        virtual void retrieveInt32() = 0;                     // 移除已读的32位整数
        virtual int32_t readInt32() = 0;                      // 读取一个32位整数
        virtual std::string retrieveAsString(size_t len) = 0; // 读取指定长度的字符串
    };

    // 基础协议类，定义消息处理的通用接口
    class BaseProtocol
    {
    public:
        using ptr = std::shared_ptr<BaseProtocol>; // 智能指针类型

        virtual bool canProcessed(const BaseBuffer::ptr &buf) = 0;                     // 判断是否可以处理缓冲区数据
        virtual bool onMessage(const BaseBuffer::ptr &buf, BaseMessage::ptr &msg) = 0; // 处理消息
        virtual std::string serialize(const BaseMessage::ptr &msg) = 0;                // 序列化消息
    };

    // 基础连接类，定义网络连接的通用接口
    class BaseConnection
    {
    public:
        using ptr = std::shared_ptr<BaseConnection>; // 智能指针类型

        virtual void send(const BaseMessage::ptr &msg) = 0; // 发送消息
        virtual void shutdown() = 0;                        // 关闭连接
        virtual bool connected() = 0;                       // 检查连接状态
    };

    // 连接回调函数类型
    using ConnectionCallback = std::function<void(const BaseConnection::ptr &)>;
    using CloseCallback = std::function<void(const BaseConnection::ptr &)>;
    using MessageCallback = std::function<void(const BaseConnection::ptr &, BaseMessage::ptr &)>;

    // 基础服务器类，定义服务器的通用接口
    class BaseServer
    {
    public:
        using ptr = std::shared_ptr<BaseServer>; // 智能指针类型

        virtual void setConnectionCallback(const ConnectionCallback &cb) { _cb_connection = cb; } // 设置连接回调
        virtual void setCloseCallback(const CloseCallback &cb) { _cb_close = cb; }                // 设置关闭回调
        virtual void setMessageCallback(const MessageCallback &cb) { _cb_message = cb; }          // 设置消息回调
        virtual void start() = 0;                                                                 // 启动服务器

    protected:
        ConnectionCallback _cb_connection; // 连接回调
        CloseCallback _cb_close;           // 关闭回调
        MessageCallback _cb_message;       // 消息回调
    };

    // 基础客户端类，定义客户端的通用接口
    class BaseClient
    {
    public:
        using ptr = std::shared_ptr<BaseClient>; // 智能指针类型

        virtual void setConnectionCallback(const ConnectionCallback &cb) { _cb_connection = cb; } // 设置连接回调
        virtual void setCloseCallback(const CloseCallback &cb) { _cb_close = cb; }                // 设置关闭回调
        virtual void setMessageCallback(const MessageCallback &cb) { _cb_message = cb; }          // 设置消息回调
        virtual void connect() = 0;                                                               // 建立连接
        virtual void shutdown() = 0;                                                              // 关闭连接
        virtual bool send(const BaseMessage::ptr &) = 0;                                          // 发送消息
        virtual BaseConnection::ptr connection() = 0;                                             // 获取连接对象
        virtual bool connected() = 0;                                                             // 检查连接状态

    protected:
        ConnectionCallback _cb_connection; // 连接回调
        CloseCallback _cb_close;           // 关闭回调
        MessageCallback _cb_message;       // 消息回调
    };
}